import Taro from '@tarojs/taro'
import { BASE_URL } from '../config/env'
import { storage, request as platformRequest } from '../utils/platform'

// 获取本地存储的安全函数
const getStorage = (key) => {
  try {
    return storage.getSync(key)
  } catch (e) {
    console.error('获取存储失败:', e)
    return null
  }
}

/**
 * 统一请求封装
 * @param {string} url - 请求路径
 * @param {string} method - 请求方法
 * @param {object} data - 请求参数
 * @param {object} header - 请求头
 * @returns {Promise} - 请求Promise
 */
export const request = async (url, method = 'GET', data = {}, header = {}) => {
  // 获取本地存储的token
  const token = getStorage('token')
  
  const defaultHeader = {
    'Content-Type': 'application/json',
    // 如果有token，添加到请求头
    ...(token ? { 'Authorization': token } : {})
  }
  
  console.log(`API请求: ${method} ${url}`, { data, token: token ? `${token.substring(0, 20)}...` : 'null' })

  try {
    const response = await platformRequest.send({
      url: `${BASE_URL}${url}`,
      method,
      data,
      header: { ...defaultHeader, ...header }
    })
    
    console.log(`API响应: ${method} ${url}`, response)
    
    // 判断请求是否成功 (根据实际API响应结构调整)
    if (response.statusCode >= 200 && response.statusCode < 300) {
      return response.data
    }
    
    // 处理错误响应
    console.error(`API错误: ${method} ${url}`, response)
    const error = new Error(response.data?.message || '请求失败')
    error.status = response.statusCode
    error.data = response.data
    throw error
  } catch (error) {
    console.error(`API异常: ${method} ${url}`, error)
    // 处理网络错误或其他异常
    if (error.errMsg) {
      throw new Error('网络请求失败，请检查网络连接')
    }
    throw error
  }
}

/**
 * 登录API
 * @param {string} name - 用户名
 * @param {string} password - 密码
 * @returns {Promise} - 登录结果
 */
export const login = async (name, password) => {
  console.log('调用登录API', { name })
  try {
    // 使用URL查询参数而不是请求体
    const result = await request(`/auth/login?name=${name}&password=${password}`, 'POST')
    console.log('登录API结果', result)
    return result
  } catch (error) {
    console.error('登录API错误', error)
    throw error
  }
}

/**
 * 注册API
 * @param {string} name - 用户名
 * @param {string} password - 密码
 * @returns {Promise} - 注册结果
 */
export const register = async (name, password) => {
  console.log('调用注册API', { name })
  try {
    // 根据API要求，添加固定Authorization头信息
    const authHeader = {
      'Authorization': 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJzdWIiOiIyIiwiZXhwIjoxNzUxODU0NzUwLCJpYXQiOjE3NTE3NjgzNTB9.XQbkVqHl8Hr7zaBTj-vdc1eB4o9StE4XLv4sE1y6qPgc2K41fwZjk7Fe3EulVYIiohbBKRq2trMLq2CQcQNMnA'
    }
    // 使用URL查询参数而不是请求体
    const result = await request(`/auth/register?name=${name}&password=${password}`, 'POST', {}, authHeader)
    console.log('注册API结果', result)
    return result
  } catch (error) {
    console.error('注册API错误', error)
    throw error
  }
} 

/**
 * 获取用户信息API
 * @returns {Promise} - 用户详细信息
 */
export const getUserInfo = async () => {
  console.log('调用获取用户信息API')
  try {
    const result = await request('/user/info', 'GET')
    console.log('获取用户信息API结果', result)
    return result.data
  } catch (error) {
    console.error('获取用户信息API错误', error)
    throw error
  }
}

/**
 * 更新用户头像API
 * @param {string} photoPath - 用户头像图片路径
 * @returns {Promise} - 更新结果
 */
export const updatePhoto = async (photoPath) => {
  console.log('调用更新用户头像API', { photoPath })
  try {
    if (!photoPath) {
      throw new Error('头像路径不能为空')
    }
    
    const uploadResult = await platformRequest.uploadFile({
      url: `${BASE_URL}/user/updatePhoto`,
      filePath: photoPath,
      name: 'photo',
      header: {
        'Authorization': getStorage('token')
      }
    })
    
    // 解析上传结果
    if (uploadResult.statusCode >= 200 && uploadResult.statusCode < 300) {
      const result = JSON.parse(uploadResult.data)
      console.log('更新用户头像API结果', result)
      return result
    } else {
      console.error('更新用户头像API错误', uploadResult)
      throw new Error(uploadResult.data?.message || '更新头像失败')
    }
  } catch (error) {
    console.error('更新用户头像API错误', error)
    throw error
  }
}

/**
 * 更新用户简介API
 * @param {string} introduce - 用户个人简介
 * @returns {Promise} - 更新结果
 */
export const updateIntroduce = async (introduce) => {
  console.log('调用更新用户简介API', { introduce })
  try {
    // 使用URL查询参数而不是请求体，与其他API保持一致
    const result = await request(`/user/updateIntroduce?introduce=${encodeURIComponent(introduce || '')}`, 'POST')
    console.log('更新用户简介API结果', result)
    return result
  } catch (error) {
    console.error('更新用户简介API错误', error)
    throw error
  }
}

/**
 * 更新用户基本信息API（兼容旧版本）
 * @param {string} introduce - 用户个人简介
 * @param {string} photoPath - 用户头像图片路径，如果为null则不上传头像内容
 * @returns {Promise} - 更新结果
 */
export const updateUserInfo = async (introduce, photoPath = null) => {
  console.log('调用更新用户信息API（兼容模式）', { introduce, photoPath })
  try {
    const results = []
    
    // 如果有头像需要更新
    if (photoPath) {
      const photoResult = await updatePhoto(photoPath)
      results.push(photoResult)
    }
    
    // 如果有简介需要更新
    if (introduce !== null && introduce !== undefined) {
      const introduceResult = await updateIntroduce(introduce)
      results.push(introduceResult)
    }
    
    // 返回最后一个结果，或者成功标识
    if (results.length > 0) {
      return results[results.length - 1]
    } else {
      return { success: true, message: '没有需要更新的内容' }
    }
  } catch (error) {
    console.error('更新用户信息API错误', error)
    throw error
  }
} 

/**
 * 修改用户密码API
 * @param {string} oldpwd - 旧密码
 * @param {string} newpwd - 新密码
 * @returns {Promise} - 修改密码结果
 */
export const updatePassword = async (oldpwd, newpwd) => {
  console.log('调用修改密码API')
  try {
    const result = await request(`/user/updatePassword?oldpwd=${oldpwd}&newpwd=${newpwd}`, 'POST')
    console.log('修改密码API结果', result)
    return result
  } catch (error) {
    console.error('修改密码API错误', error)
    throw error
  }
} 

/**
 * 获取历史对话API
 * @param {number} begin - 开始索引
 * @param {number} length - 获取数量
 * @param {number} group - 消息类型 (1-用户, 2-AI)
 * @returns {Promise} - 历史对话结果
 */
export const getHistoryMessages = async (begin = 0, length = 10, group = 2) => {
  console.log('调用获取历史对话API', { begin, length, group })
  try {
    const result = await request(`/main/getRange?begin=${begin}&length=${length}&group=${group}`, 'GET')
    console.log('获取历史对话API结果', result)
    return result
  } catch (error) {
    console.error('获取历史对话API错误', error)
    throw error
  }
}

/**
 * 获取用户详细信息API
 * @returns {Promise} - 用户详细信息
 */
export const getUserDetail = async () => {
  console.log('调用获取用户详细信息API')
  try {
    const result = await request('/user/detail/info', 'GET')
    console.log('获取用户详细信息API结果', result)
    return result
  } catch (error) {
    console.error('获取用户详细信息API错误', error)
    throw error
  }
}

/**
 * 更新用户详细信息API
 * @param {object} detailData - 用户详细信息数据
 * @returns {Promise} - 更新结果
 */
export const updateUserDetail = async (detailData) => {
  console.log('调用更新用户详细信息API', detailData)
  try {
    const result = await request('/user/detail/update', 'POST', detailData)
    console.log('更新用户详细信息API结果', result)
    return result
  } catch (error) {
    console.error('更新用户详细信息API错误', error)
    throw error
  }
}

/**
 * 发送消息API
 * @param {string} message - 要发送的消息
 * @param {boolean} stream - 是否使用流式传输
 * @returns {Promise} - 发送消息结果
 */
export const sendMessage = async (message, stream ) => {
  console.log('调用发送消息API', { message, stream })
  try {
    // 使用新的端点/main/ask，并添加stream参数
    const url = `/main/ask?question=${encodeURIComponent(message)}&stream=1`
    
    if (stream) {
      // 流式请求不使用统一request函数，直接返回请求对象以便处理流
      console.log('发起流式请求', url)
      return {
        url: `${BASE_URL}${url}`,
        method: 'POST',
        header: {
          'Content-Type': 'application/json',
          'Authorization': getStorage('token')
        }
      }
    } else {
      // 非流式请求使用原有方式
      const result = await request(url, 'POST')
      console.log('发送消息API结果', result)
      return result
    }
  } catch (error) {
    console.error('发送消息API错误', error)
    throw error
  }
}

/**
 * 获取情感分析图表数据API
 * @param {number} items - 节点数
 * @param {number} days - 最近天数
 * @returns {Promise} - 图表数据结果
 */
export const getEmotionChartData = async (items = 20, days = 3) => {
  console.log('调用获取情感分析图表数据API', { items, days })
  try {
    const result = await request(`/user/emotion/chart?items=${items}&days=${days}`, 'GET')
    console.log('获取情感分析图表数据API结果', result)
    return result
  } catch (error) {
    console.error('获取情感分析图表数据API错误', error)
    throw error
  }
}

/**
 * 获取用户情感得分列表API
 * @param {number} page - 页数
 * @param {number} size - 每页个数
 * @returns {Promise} - 得分列表结果
 */
export const getEmotionPageList = async (page = 1, size = 10) => {
  console.log('调用获取用户情感得分列表API', { page, size })
  try {
    const result = await request(`/user/emotion/pagelist?page=${page}&size=${size}`, 'GET')
    console.log('获取用户情感得分列表API结果', result)
    return result
  } catch (error) {
    console.error('获取用户情感得分列表API错误', error)
    throw error
  }
}